package ScheduledThreadPoolExecutor_17;

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;

public class 定时任务和周期性任务 {

    public static void main(String[] args) {
        // 创建包含10个线程的调度线程池
        ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(10);

        System.out.println("开始调度任务...");

        // 示例1：延迟执行一次性任务
        ScheduledFuture<?> oneTimeTask = scheduler.schedule(
                new Runnable() {
                    public void run() {
                        try {
                            System.out.println("一次性任务执行 - 线程: " + Thread.currentThread().getName());
                            // 模拟任务执行时间
                            Thread.sleep(500);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                },
                2,  // 延迟2秒执行
                TimeUnit.SECONDS
        );

        // 示例2：固定延迟的周期性任务（每次执行结束后延迟固定时间再执行下一次）
        scheduler.scheduleWithFixedDelay(
                new Runnable() {
                    public void run() {
                        try {
                            System.out.println("固定延迟周期性任务执行 - 线程: " + Thread.currentThread().getName());
                            // 模拟任务执行时间
                            Thread.sleep(800);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                },
                1,  // 初始延迟1秒
                3,  // 每次执行结束后延迟3秒
                TimeUnit.SECONDS
        );

        // 示例3：固定速率的周期性任务（按固定频率执行，不考虑任务执行时间）
        scheduler.scheduleAtFixedRate(
                new Runnable() {
                    public void run() {
                        try {
                            System.out.println("固定速率周期性任务执行 - 线程: " + Thread.currentThread().getName());
                            // 模拟任务执行时间
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                },
                1,  // 初始延迟1秒
                2,  // 每2秒执行一次
                TimeUnit.SECONDS
        );

        // 主线程休眠一段时间，以便观察任务执行
        try {
            Thread.sleep(15000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 关闭线程池
        scheduler.shutdown();
        System.out.println("调度器已关闭");
    }
}